The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point in your pull request via creating an issue comment (i.e. comment on the pull request page) using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for Github and other Google products, sign up here.

You can also get AI-powered code generation, chat, as well as code reviews directly in the IDE at no cost with the Gemini Code Assist IDE Extension.

client/request.go (1)

594-605: Effective value resolution is correct and robust

Falls back to the client setting when unset; default false if no client is attached yet. Consider documenting this precedence in the method comment for discoverability.

client/client_test.go (3)

1750-1767: Optional: make SSE handler actually stream (flush between events) for stronger signal

Right now the handler writes three messages and returns. This can still pass even if the server buffers and sends a single chunk. Consider using SetBodyStreamWriter and flushing between writes to exercise true streaming behavior. Example:

app.Get("/sse", func(c fiber.Ctx) error {
	c.Set("Content-Type", "text/event-stream")
	c.Set("Cache-Control", "no-cache")
	c.Set("Connection", "keep-alive")

	c.Context().SetBodyStreamWriter(func(w *bufio.Writer) {
		msgs := []string{"data: message 1\n\n", "data: message 2\n\n", "data: message 3\n\n"}
		for _, m := range msgs {
			_, _ = w.WriteString(m)
			_ = w.Flush()
			time.Sleep(10 * time.Millisecond)
		}
	})
	return nil
})

This reduces false positives where streaming isn’t actually occurring.

---

1836-1841: Strengthen fallback contract when streaming is disabled by reading BodyStream

You assert BodyStream() is non-nil, but don’t verify it yields the same content as Body() in the fallback path. Read it and compare.

Apply this diff:

 	body := resp.Body()
 	require.Equal(t, "Hello, World!", string(body))

 	bodyStream := resp.BodyStream()
 	require.NotNil(t, bodyStream)
+	streamed, err := io.ReadAll(bodyStream)
+	require.NoError(t, err)
+	require.Equal(t, body, streamed)

---

1854-1883: Please add a follow-up request and Reset() behavior test to guard against per-request overrides leaking

You’ve already verified the getter/inheritance logic for StreamResponseBody, but we’re still missing two important checks in client/client_test.go around lines 1854–1883:

• A second request on the same client after an override, to ensure the per-request override doesn’t persist.
• Exercising Request.Reset() to confirm it clears any per-request streaming flag and falls back to the client default.

Suggested diff to insert after the existing assertions:

 	req2 := client.R().SetStreamResponseBody(false)
 	require.False(t, req2.StreamResponseBody())

+	// Follow-up call: ensure the override didn’t leak into actual behavior.
+	resp2b, err := req2.Get("http://" + addr + "/test")
+	require.NoError(t, err)
+	defer resp2b.Close()
+	require.Equal(t, "Hello, World!", string(resp2b.Body()))

 	clientWithStreaming := New().SetStreamResponseBody(true)
 	req3 := clientWithStreaming.R()
 	require.True(t, req3.StreamResponseBody()) // Should inherit from client
 	req4 := client.R().
 		SetStreamResponseBody(true).
 		SetTimeout(time.Second * 5).
 		SetStreamResponseBody(false)
 	require.False(t, req4.StreamResponseBody())
+
+	// After Reset, per-request override should be cleared and revert to client setting (false).
+	reqReset := client.R().SetStreamResponseBody(true)
+	reqReset.Reset()
+	require.False(t, reqReset.StreamResponseBody())

This will catch regressions where the underlying fasthttp flag isn’t properly restored and confirm Reset() clears the override.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

client/client.go (2)

538-557: Reset should also clear streamResponseBody to default false

Client.Reset clears most flags but leaves streamResponseBody unchanged, leading to surprising behavior post-reset.

 func (c *Client) Reset() {
 	c.fasthttp = &fasthttp.Client{}
 	c.baseURL = ""
 	c.timeout = 0
 	c.userAgent = ""
 	c.referer = ""
 	c.retryConfig = nil
 	c.debug = false
+	c.streamResponseBody = false

---

58-61: Guard temporary per-request flips of fasthttp.Client.StreamResponseBody with a dedicated mutex on Client

If core executes by toggling the shared fasthttp.Client.StreamResponseBody between requests, concurrent requests can race. Add a small private mutex dedicated to this toggle. This keeps the public API unchanged and avoids overloading c.mu, which guards other state.

Apply:

 type Client struct {
  	logger   log.CommonLogger
  	fasthttp *fasthttp.Client
@@
-	timeout            time.Duration
-	mu                 sync.RWMutex
-	debug              bool
-	streamResponseBody bool
+	timeout            time.Duration
+	mu                 sync.RWMutex
+	debug              bool
+	streamResponseBody bool
+	// protects temporary flips of fasthttp.Client.StreamResponseBody during per-request execution
+	streamRespMu       sync.Mutex
 }

To confirm whether the toggle approach is used (vs. cloning a temp fasthttp.Client), run:

#!/bin/bash
# Inspect how StreamResponseBody is applied during execution.
rg -n -C2 --type=go 'StreamResponseBody' client/core.go client | sed -n '1,200p'

client/response_test.go (1)

598-611: Fix flakiness: copy Body() before closing resp1

normalBody aliases resp1’s internal buffer; after Close(), pooled buffers may be reused, causing nondeterministic failures. Copy the bytes before closing.

-		defer resp1.Close()
-		normalBody := resp1.Body()
+		defer resp1.Close()
+		normalBody := append([]byte(nil), resp1.Body()...)

client/client.go (2)

439-451: API shape LGTM; document precedence explicitly in the comment

The getter/setter are clear and chainable. Add one line noting that a request-level setting overrides the client-level default for discoverability.

 // SetStreamResponseBody enables or disables response body streaming.
 // When enabled, the response body can be read as a stream using BodyStream()
 // instead of being fully loaded into memory. This is useful for large responses
-// or server-sent events.
+// or server-sent events. Note: a per-request setting (Request.SetStreamResponseBody)
+// overrides this client-level default.
 func (c *Client) SetStreamResponseBody(enable bool) *Client {
 	c.streamResponseBody = enable
 	return c
 }

---

563-575: Optional: plumb StreamResponseBody through Config for convenience

Many helpers accept Config; adding an optional pointer makes it easy to set streaming per call without constructing a Request manually.

 type Config struct {
 	Ctx          context.Context //nolint:containedctx // It's needed to be stored in the config.
 	Body         any
 	Header       map[string]string
 	Param        map[string]string
 	Cookie       map[string]string
 	PathParam    map[string]string
 	FormData     map[string]string
 	UserAgent    string
 	Referer      string
 	File         []*File
 	Timeout      time.Duration
 	MaxRedirects int
+	// Optional per-request override; when set, overrides the client default.
+	StreamResponseBody *bool
 }
@@
 	if cfg.MaxRedirects != 0 {
 		req.SetMaxRedirects(cfg.MaxRedirects)
 	}
 
+	if cfg.StreamResponseBody != nil {
+		req.SetStreamResponseBody(*cfg.StreamResponseBody)
+	}
+
 	if cfg.Body != nil {
 		req.SetJSON(cfg.Body)
 		return
 	}

Also applies to: 577-635

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

client/core.go (1)

132-141: Minor duplication: unify Do vs DoRedirects callsites

The four callsites using fastHTTPClient.Do/DoRedirects under retry and non-retry paths duplicate logic. A tiny helper makes it harder to regress:

- if cfg != nil {
-   err = retry.NewExponentialBackoff(*cfg).Retry(func() error {
-     if shouldRedirect {
-       return fastHTTPClient.DoRedirects(reqv, respv, c.req.maxRedirects)
-     }
-     return fastHTTPClient.Do(reqv, respv)
-   })
- } else {
-   if shouldRedirect {
-     err = fastHTTPClient.DoRedirects(reqv, respv, c.req.maxRedirects)
-   } else {
-     err = fastHTTPClient.Do(reqv, respv)
-   }
- }
+call := func() error {
+  if shouldRedirect {
+    return fastHTTPClient.DoRedirects(reqv, respv, c.req.maxRedirects)
+  }
+  return fastHTTPClient.Do(reqv, respv)
+}
+if cfg != nil {
+  err = retry.NewExponentialBackoff(*cfg).Retry(call)
+} else {
+  err = call()
+}

Low impact, but improves readability.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

client/response.go (2)

92-101: Tighten BodyStream docs: lifetime, connection reuse, and Body() emptiness when streaming

The code is fine. Please clarify the contract and call order to prevent misuse with pooled responses and fasthttp’s connection reuse.

Apply this doc tweak:

-// BodyStream returns the response body as a stream reader.
-// Note: When using BodyStream(), the response body is not copied to memory,
-// so calling Body() afterwards may return an empty slice.
+// BodyStream returns an io.Reader for the response body.
+// If streaming was enabled (via Request.SetStreamResponseBody, Client.SetStreamResponseBody,
+// or the underlying fasthttp.Client.StreamResponseBody), the reader yields bytes directly from
+// the connection without buffering in memory.
+//
+// Important:
+// - Consume the reader before calling Response.Close().
+// - Read the stream to EOF to allow connection reuse by the underlying client.
+// - When streaming is enabled, Body() (and helpers like String/JSON/XML/CBOR/Save) may be empty;
+//   prefer io.Copy with BodyStream() for large responses.
+// If streaming is not enabled, BodyStream returns a bytes.Reader over Body().
 func (r *Response) BodyStream() io.Reader {

---

150-165: Save() ignores streaming and closes caller’s writer — stream from BodyStream() and don’t close external writers

• Using Body() makes Save() write an empty file/output when streaming is enabled.
• Closing an io.Writer that the function didn’t open is surprising and can break callers.

Apply this minimal change:

-    if _, err = io.Copy(outFile, bytes.NewReader(r.Body())); err != nil {
+    if _, err = io.Copy(outFile, r.BodyStream()); err != nil {
       return fmt.Errorf("failed to write response body to file: %w", err)
     }
@@
-  case io.Writer:
-    if _, err := io.Copy(p, bytes.NewReader(r.Body())); err != nil {
+  case io.Writer:
+    if _, err := io.Copy(p, r.BodyStream()); err != nil {
       return fmt.Errorf("failed to write response body to io.Writer: %w", err)
     }
-    defer func() {
-      if pc, ok := p.(io.WriteCloser); ok {
-        _ = pc.Close() //nolint:errcheck // not needed
-      }
-    }()
     return nil

Follow-up (optional): consider adding a short note in Save()’s doc that it respects streaming and doesn’t close external writers.

client/response_test.go (1)

606-629: Avoid retaining Body()’s internal buffer across Close; also assert Body() is empty when streaming

To prevent future flakiness with pooled buffers and to codify the streaming contract, copy the non-streamed body and add an assertion that Body() is empty when streaming is enabled.

Apply:

-    defer resp1.Close()
-    normalBody := resp1.Body()
+    defer resp1.Close()
+    normalBody := append([]byte(nil), resp1.Body()...) // copy before pool reuse
@@
-    streamedBody, err := io.ReadAll(resp2.BodyStream())
+    streamedBody, err := io.ReadAll(resp2.BodyStream())
     require.NoError(t, err)
     require.Equal(t, normalBody, streamedBody)
+    // streaming mode shouldn't buffer Body()
+    require.Len(t, resp2.Body(), 0)

client/response_test.go (1)

542-629: Add a streaming Save() regression test (uses BodyStream and does not close external writer)

Given the Save() fix, add coverage to ensure we don’t regress: the writer must not be closed by Save(), and content must be streamed correctly when streaming is enabled.

Insert this new subtest at the end of Test_Response_BodyStream (before the final closing brace):

+   t.Run("Save streams and does not close external writer", func(t *testing.T) {
+     t.Parallel()
+
+     server := startTestServer(t, func(app *fiber.App) {
+       app.Get("/stream", func(c fiber.Ctx) error {
+         return c.SendString("streaming data")
+       })
+     })
+     defer server.stop()
+
+     client := New().SetDial(server.dial()).SetStreamResponseBody(true)
+     resp, err := client.Get("http://example.com/stream")
+     require.NoError(t, err)
+     defer resp.Close()
+
+     type trackingBuf struct {
+       bytes.Buffer
+       closed bool
+     }
+     // implements io.WriteCloser to verify Save() does not close it
+     var w = &trackingBuf{}
+     // wrap with NopCloser-like shim
+     writer := struct {
+       io.Writer
+       io.Closer
+     }{
+       Writer: w,
+       Closer: io.CloserFunc(func() error {
+         w.closed = true
+         return nil
+       }),
+     }
+
+     // Save to writer; it must not close it
+     err = resp.Save(writer)
+     require.NoError(t, err)
+     require.Equal(t, "streaming data", w.String())
+     require.False(t, w.closed, "Save must not close external writers")
+   })

If you prefer, we can place a similar subtest under Test_Response_Save.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

client/response.go (2)

92-101: Tighten BodyStream contract; clarify lifetime and fallback behavior

Doc is still a bit vague about ordering/lifetime and the fallback to an in-memory reader. Propose expanding the comment to state the contract explicitly and reduce surprises.

-// BodyStream returns the response body as a stream reader.
-// Note: When using BodyStream(), the response body is not copied to memory,
-// so calling Body() afterwards may return an empty slice.
+// BodyStream returns an io.Reader for the response body.
+//
+// If streaming was enabled (via Request.SetStreamResponseBody, Client.SetStreamResponseBody,
+// or the underlying fasthttp.Client.StreamResponseBody), the reader yields data directly from
+// the connection without buffering. Otherwise, it returns a bytes.Reader over Body().
+//
+// Important:
+// - Consume the reader before calling Response.Close().
+// - When streaming is enabled, Body() (and helpers like String/JSON/XML/CBOR/Save) may observe
+//   an empty body. Prefer io.Copy with BodyStream() for large responses.
 func (r *Response) BodyStream() io.Reader {
   if stream := r.RawResponse.BodyStream(); stream != nil {
     return stream
   }
   // If streaming is not enabled, return a bytes.Reader from the regular body
   return bytes.NewReader(r.RawResponse.Body())
 }

---

161-172: Make Save() always stream via BodyStream(); also stream when saving to a file

The writer branch partially streams, but the file path branch still buffers via Body(). Since BodyStream() already falls back to a bytes.Reader when streaming isn’t enabled, you can unconditionally copy from BodyStream() in both branches. This avoids large in-memory buffers and simplifies the code.

@@
-    if _, err = io.Copy(outFile, bytes.NewReader(r.Body())); err != nil {
+    if _, err = io.Copy(outFile, r.BodyStream()); err != nil {
       return fmt.Errorf("failed to write response body to file: %w", err)
     }
@@
-  case io.Writer:
-    var err error
-    if r.IsStreaming() {
-      _, err = io.Copy(p, r.BodyStream())
-    } else {
-      _, err = io.Copy(p, bytes.NewReader(r.Body()))
-    }
-
-    if err != nil {
-      return fmt.Errorf("failed to write response body to writer: %w", err)
-    }
-
-    return nil
+  case io.Writer:
+    if _, err := io.Copy(p, r.BodyStream()); err != nil {
+      return fmt.Errorf("failed to write response body to writer: %w", err)
+    }
+    return nil

Follow-up: consider adding/adjusting tests to cover Save(filePath) with streaming enabled (e.g., large response) to ensure we don’t regress. I can draft that if helpful.

client/core.go (1)

84-120: Per-request allocating a new fasthttp.Client loses connection pooling and adds substantial latency/TLS overhead

Constructing a fresh *fasthttp.Client whenever the per-request streaming flag differs discards the shared connection pool and TLS session cache, causing extra TCP/TLS handshakes and reduced throughput under mixed workloads. This will regress performance for SSE/large downloads that toggle streaming on/off across requests.

Consider maintaining two long-lived internal clients (streaming vs non-streaming) on Client and routing each request accordingly. Here's a suggested implementation:

Add to client/client.go:

+// In Client struct:
+streamingFHC *fasthttp.Client // lazily initialized clone with StreamResponseBody=true
+
+// pickFastHTTPClient returns a pooled client configured for the requested streaming mode.
+func (c *Client) pickFastHTTPClient(stream bool) *fasthttp.Client {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	if stream == c.streamResponseBody {
+		return c.fasthttp
+	}
+	// Lazily build the streaming variant once and reuse it.
+	if stream && c.streamingFHC != nil {
+		return c.streamingFHC
+	}
+	return c.initStreamingClientLocked(stream)
+}
+
+// initStreamingClientLocked clones exported config into a new fasthttp.Client.
+// c.mu must be held by the caller.
+func (c *Client) initStreamingClientLocked(stream bool) *fasthttp.Client {
+	o := c.fasthttp
+	clone := &fasthttp.Client{
+		Dial:                          o.Dial,
+		DialDualStack:                 o.DialDualStack,
+		TLSConfig:                     o.TLSConfig,
+		MaxConnsPerHost:               o.MaxConnsPerHost,
+		MaxIdleConnDuration:           o.MaxIdleConnDuration,
+		MaxConnDuration:               o.MaxConnDuration,
+		ReadTimeout:                   o.ReadTimeout,
+		WriteTimeout:                  o.WriteTimeout,
+		ReadBufferSize:                o.ReadBufferSize,
+		WriteBufferSize:               o.WriteBufferSize,
+		MaxResponseBodySize:           o.MaxResponseBodySize,
+		NoDefaultUserAgentHeader:      o.NoDefaultUserAgentHeader,
+		DisableHeaderNamesNormalizing: o.DisableHeaderNamesNormalizing,
+		DisablePathNormalizing:        o.DisablePathNormalizing,
+		MaxIdemponentCallAttempts:     o.MaxIdemponentCallAttempts,
+		Name:                          o.Name,
+		ConfigureClient:               o.ConfigureClient,
+		StreamResponseBody:            stream,
+	}
+	if stream {
+		c.streamingFHC = clone
+	}
+	return clone
+}

Then simplify this code block:

-	// Determine which client to use - create a new one if StreamResponseBody differs
-	var fastHTTPClient *fasthttp.Client
-	requestStreamResponseBody := c.req.StreamResponseBody()
-	c.client.mu.RLock()
-	clientStream := c.client.streamResponseBody
-	original := c.client.fasthttp
-
-	if requestStreamResponseBody != clientStream {
-		// Request setting differs from client setting, create a temporary client
-
-		fastHTTPClient = &fasthttp.Client{
-			Dial:                          original.Dial,
-			DialDualStack:                 original.DialDualStack,
-			TLSConfig:                     original.TLSConfig,
-			MaxConnsPerHost:               original.MaxConnsPerHost,
-			MaxIdleConnDuration:           original.MaxIdleConnDuration,
-			MaxConnDuration:               original.MaxConnDuration,
-			ReadTimeout:                   original.ReadTimeout,
-			WriteTimeout:                  original.WriteTimeout,
-			ReadBufferSize:                original.ReadBufferSize,
-			WriteBufferSize:               original.WriteBufferSize,
-			MaxResponseBodySize:           original.MaxResponseBodySize,
-			NoDefaultUserAgentHeader:      original.NoDefaultUserAgentHeader,
-			DisableHeaderNamesNormalizing: original.DisableHeaderNamesNormalizing,
-			DisablePathNormalizing:        original.DisablePathNormalizing,
-			MaxIdemponentCallAttempts:     original.MaxIdemponentCallAttempts,
-			Name:                          original.Name,
-			ConfigureClient:               original.ConfigureClient,
-
-			// Request-specific override
-			StreamResponseBody: requestStreamResponseBody,
-		}
-	} else {
-		fastHTTPClient = original
-	}
-	c.client.mu.RUnlock()
+	// Determine which client to use without sacrificing connection pooling
+	requestStreamResponseBody := c.req.StreamResponseBody()
+	fastHTTPClient := c.client.pickFastHTTPClient(requestStreamResponseBody)

This keeps pooling intact and avoids repeated allocation while maintaining thread safety.

client/response.go (1)

103-106: IsStreaming semantics are OK; consider documenting that it reflects fasthttp.BodyStream presence

Minor: IsStreaming simply mirrors RawResponse.BodyStream() != nil. A short note in the comment that this reports whether the underlying fasthttp response is streaming (not whether data remains unread) would avoid confusion.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

client/response_test.go (2)

704-726: Fix buffer retention issue before closing Response.

Line 718 stores a reference to resp1.Body() in normalBody, then Line 717 defers resp1.Close(). After closing, the internal buffer can be reused by the pool, leading to flaky comparisons.

Apply this diff to copy the bytes before closing:

 	client1 := New().SetDial(server.dial())
 	resp1, err := client1.Get("http://example.com/stream")
 	require.NoError(t, err)
 	defer resp1.Close()
-	normalBody := resp1.Body()
+	normalBody := append([]byte(nil), resp1.Body()...)

---

779-828: Test name says "incremental reads" but doesn't test incremental behavior.

The subtest uses io.ReadAll (line 818) which reads the entire response at once, not incrementally. Additionally, the server handler doesn't use SetBodyStreamWriter to truly stream the response—it uses ImmediateHeaderFlush which may not force streaming semantics.

To properly test incremental reads:

1. Use a buffered reader and read line-by-line or in chunks
2. Use SetBodyStreamWriter on the server to ensure true streaming:

c.Context().SetBodyStreamWriter(func(w *bufio.Writer) {
    messages := []string{
        "data: event 1\n\n",
        "data: event 2\n\n",
        "data: event 3\n\n",
        "data: event 4\n\n",
    }
    for i, msg := range messages {
        _, _ = w.WriteString(msg)
        _ = w.Flush()
        if i < len(messages)-1 {
            time.Sleep(5 * time.Millisecond)
        }
    }
})

Then read incrementally:

r := bufio.NewReader(bodyStream)
for i := 1; i <= 4; i++ {
    line, err := r.ReadString('\n')
    require.NoError(t, err)
    require.Contains(t, line, fmt.Sprintf("data: event %d", i))
    _, _ = r.ReadString('\n') // consume blank line
}

client/response_test.go (2)

728-777: Consider using SetBodyStreamWriter for guaranteed streaming behavior.

The test uses ImmediateHeaderFlush (line 740) which may not guarantee true streaming. For more robust streaming tests, consider using SetBodyStreamWriter:

c.Context().SetBodyStreamWriter(func(w *bufio.Writer) {
    chunks := []string{"chunk1", "chunk2", "chunk3"}
    for i, chunk := range chunks {
        _, _ = w.WriteString(chunk)
        _ = w.Flush()
        if i < len(chunks)-1 {
            time.Sleep(10 * time.Millisecond)
        }
    }
})

This ensures the server actually streams rather than buffering and sending at once.

---

830-876: Consider using SetBodyStreamWriter for true progressive streaming.

Similar to the chunked test, this test uses ImmediateHeaderFlush which may not force true streaming behavior. Using SetBodyStreamWriter would guarantee progressive writes and better validate the streaming feature.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

client/response_test.go (2)

779-828: Read SSE progressively; avoid io.ReadAll for “incremental reads”

Use a bufio.Reader and consume event by event to validate streaming semantics.

@@
-        bodyStream := resp.BodyStream()
-        require.NotNil(t, bodyStream)
-
-        data, err := io.ReadAll(bodyStream)
-        require.NoError(t, err)
-
-        content := string(data)
-        require.Contains(t, content, "event 1")
-        require.Contains(t, content, "event 2")
-        require.Contains(t, content, "event 3")
-        require.Contains(t, content, "event 4")
-        require.Contains(t, content, "data: event")
-        require.Contains(t, content, "\n\n")
+        bodyStream := resp.BodyStream()
+        require.NotNil(t, bodyStream)
+        r := bufio.NewReader(bodyStream)
+        for i := 1; i <= 4; i++ {
+            line, err := r.ReadString('\n')
+            require.NoError(t, err)
+            require.Contains(t, line, fmt.Sprintf("data: event %d", i))
+            _, _ = r.ReadString('\n') // blank line
+        }

Add import if missing:

@@
-import (
+import (
+   "bufio"

---

714-726: Fix flakiness: copy Body() before closing the pooled response
The slice points to pooled memory; copy it before Close.

-        defer resp1.Close()
-        normalBody := resp1.Body()
+        defer resp1.Close()
+        normalBody := append([]byte(nil), resp1.Body()...)

ctx_test.go (1)

5585-5596: Release acquired context to avoid pool leakage in tests

Add a deferred ReleaseCtx to mirror prevailing patterns and keep pools healthy under -race.

-        c := app.AcquireCtx(&fasthttp.RequestCtx{})
+        c := app.AcquireCtx(&fasthttp.RequestCtx{})
+        defer app.ReleaseCtx(c)

client/response.go (2)

92-101: Tighten BodyStream contract docs

Clarify lifetime/ordering and fallback to bytes.Reader for non-streaming responses.

-// BodyStream returns the response body as a stream reader.
-// Note: When using BodyStream(), the response body is not copied to memory,
-// so calling Body() afterwards may return an empty slice.
+// BodyStream returns an io.Reader for the response body.
+// When the underlying client/request enabled streaming, the reader yields data
+// directly from the connection without buffering; consume it before Close().
+// When streaming is disabled, BodyStream returns a bytes.Reader over Body().
+// Note: If you read via BodyStream while streaming is enabled, Body() may be empty.

---

155-160: Simplify Save: always copy from BodyStream()

BodyStream already returns a bytes.Reader when not streaming; drop the IsStreaming branches and copy once.

-        if r.IsStreaming() {
-            _, err = io.Copy(outFile, r.BodyStream())
-        } else {
-            _, err = io.Copy(outFile, bytes.NewReader(r.Body()))
-        }
+        _, err = io.Copy(outFile, r.BodyStream())
@@
-        var err error
-        if r.IsStreaming() {
-            _, err = io.Copy(p, r.BodyStream())
-        } else {
-            _, err = io.Copy(p, bytes.NewReader(r.Body()))
-        }
+        _, err := io.Copy(p, r.BodyStream())

[gaby suggested io.CopyBuffer; using plain io.Copy keeps it simple and idiomatic. Based on learnings]

Also applies to: 169-177

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: ReneWerner87
Repo: gofiber/fiber PR: 0
File: :0-0
Timestamp: 2024-12-01T10:28:36.011Z
Learning: Feature request #3224 has been created to add support for square bracket notation and comma-separated values in multipart form data in Fiber, while maintaining binary data transfer capabilities. This would bring parity with the existing form-urlencoded functionality.

Learnt from: grivera64
Repo: gofiber/fiber PR: 3807
File: adapter_test.go:118-144
Timestamp: 2025-10-16T07:19:52.418Z
Learning: In the Fiber codebase, the linter does not allow `require` assertions from within HTTP handlers (including net/http-style handlers). Use `t.Fatalf`, `t.Errorf`, or similar `testing.T` methods for error handling inside handler functions instead.

Learnt from: arturmelanchyk
Repo: gofiber/fiber PR: 3768
File: client/request.go:162-166
Timestamp: 2025-09-28T17:39:26.644Z
Learning: In fasthttp-based code like gofiber, using utils.UnsafeString(key) instead of string(key) is acceptable when values are used immediately within the same call stack and not stored for later use, as it avoids allocations and aligns with fasthttp's zero-allocation design philosophy.

Learnt from: grivera64
Repo: gofiber/fiber PR: 3807
File: adapter_test.go:118-144
Timestamp: 2025-10-16T07:15:26.529Z
Learning: In Fiber v3, net/http handlers (http.Handler, http.HandlerFunc, or raw func(http.ResponseWriter, *http.Request)) can be passed directly to routing methods like app.Get(), app.Post(), etc. The framework automatically detects and wraps them internally via toFiberHandler/collectHandlers. The github.com/gofiber/fiber/v3/middleware/adaptor package is legacy and should not be suggested for tests or code using native net/http handler support.

Learnt from: efectn
Repo: gofiber/fiber PR: 3162
File: app_test.go:893-895
Timestamp: 2024-11-29T12:37:27.581Z
Learning: In the `Test_App_ShutdownWithContext` function in `app_test.go`, the `clientDone` channel is used to synchronize the client's request completion before proceeding, eliminating the need for additional `time.Sleep` calls.

Learnt from: sixcolors
Repo: gofiber/fiber PR: 2922
File: middleware/cors/utils.go:63-71
Timestamp: 2024-07-26T21:00:12.902Z
Learning: The project uses the testify/assert package for assertions in unit tests.

Learnt from: efectn
Repo: gofiber/fiber PR: 3162
File: hooks_test.go:228-228
Timestamp: 2024-12-13T08:14:22.851Z
Learning: In Go test files, prefer using the `require` methods from the `testify` package for assertions instead of manual comparisons and calls to `t.Fatal` or `t.Fatalf`.

Learnt from: ReneWerner87
Repo: gofiber/fiber PR: 3161
File: app.go:923-932
Timestamp: 2024-11-15T07:56:21.623Z
Learning: In the Fiber framework, breaking changes are acceptable when moving from version 2 to version 3, including modifications to method signatures such as in the `Test` method in `app.go`.

Learnt from: sixcolors
Repo: gofiber/fiber PR: 3016
File: middleware/session/store.go:164-167
Timestamp: 2024-10-08T19:06:06.583Z
Learning: Unit tests in this project use testify require.

Learnt from: CR
Repo: gofiber/fiber PR: 0
File: AGENTS.md:0-0
Timestamp: 2025-10-22T13:48:12.485Z
Learning: Run tests with gotestsum (Make target: test)

Learnt from: gaby
Repo: gofiber/fiber PR: 3193
File: middleware/adaptor/adaptor.go:111-111
Timestamp: 2024-11-10T23:44:13.704Z
Learning: In the `middleware/adaptor/adaptor.go` file of the Fiber framework, when updating context handling, replacing `c.Context()` with `c.RequestCtx()` is appropriate to access the `fasthttp.RequestCtx`.

Learnt from: sixcolors
Repo: gofiber/fiber PR: 3016
File: middleware/csrf/csrf_test.go:188-193
Timestamp: 2024-09-25T15:57:10.221Z
Learning: In the Fiber framework tests, using `ctx.Response.Header.Cookie` may not be suitable for parsing cookies from the response header, as it requires a `*Cookie` and fills it rather than returning a string value; thus, manual parsing of the `Set-Cookie` header may be necessary.

Learnt from: sixcolors
Repo: gofiber/fiber PR: 3016
File: middleware/session/middleware_test.go:190-191
Timestamp: 2024-09-25T17:05:06.991Z
Learning: When testing session `IdleTimeout` expiration, it's acceptable to use `time.Sleep` to simulate the passage of time in tests.

Learnt from: sixcolors
Repo: gofiber/fiber PR: 3051
File: middleware/session/session.go:215-216
Timestamp: 2024-10-08T19:06:06.583Z
Learning: Parallel tests for `Session.Save` already exist in the `middleware/session/session_test.go` file, specifically in the `Test_Session_Save` and `Test_Session_Save_Expiration` functions.